Updating a hierarchical data structure

ABSTRACT

A method and system for updating nodes in a hierarchical data structure is described. The system receives an update to a first node representing a record in a hierarchical data structure. The system determines at least one other node that needs updating based on the update to the first node. The system compares the number of nodes that need updating based upon the update to the first node to a maximum number to determine whether the number of nodes that need updating is less than, equal to and greater than the maximum number. The system performs a synchronous update of the nodes that need updating in response to a determination that the number of nodes is less than or equal to the maximum number and an asynchronous update of the nodes that need updating in response to a determination that the number of nodes is greater than the maximum number.

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains materialwhich is subject to copyright protection. The copyright owner has noobjection to the facsimile reproduction by anyone of the patent documentor the patent disclosure, as it appears in the Patent and TrademarkOffice patent file or nodes, but otherwise reserves all copyright rightswhatsoever.

TECHNICAL FIELD

The present disclosure relates generally to management of hierarchicaltree structures.

BACKGROUND

The subject matter discussed in the background section should not beassumed to be prior art merely as a result of its mention in thebackground section. Similarly, a problem mentioned in the backgroundsection or associated with the subject matter of the background sectionshould not be assumed to have been previously recognized in the priorart. The subject matter in the background section merely representsdifferent approaches, which in and of themselves may also be inventions.

The following detailed description is made with reference to thetechnology disclosed. Preferred implementations are described toillustrate the technology disclosed, not to limit its scope, which isdefined by the claims. Those of ordinary skill in the art will recognizea variety of equivalent variations on the description.

This invention relates to the field of data management, and inparticular to a system and method that facilitates generation andmanagement of a hierarchical data structure.

In order to manage large amounts of data, companies, organizations,entities and the like need to implement correspondingly large datainfrastructures. Without the large data infrastructures, storing andquerying massive amounts of data can be time consuming and expensive.

The large data infrastructures often store data logically inhierarchical data structures allowing mining or querying of the data inan efficient manner. For example, data associated with employees of acorporation may be organized first by department and then by roles ofthe employee within the department then by projects the employees arecurrently working on.

In hierarchical data structures, data is stored as a record andrepresented as nodes in the hierarchical data structure. Relationshiplinks are provided to show the relationship between the different nodes,such as a parent-child relationship. Each node has one parent node or apredecessor node unless the node is a starting or initial root node.Each node, including the root node, can also have multiple child nodes.

Conventionally, in order to retrieve or query data in a hierarchicaldata structure, the whole data structure needs to be traversed startingfrom a root node. When the size and complexity of relationships betweenthe nodes increase, traversing the relationships between the root nodeand the node containing the desired data result results in lengthydelays and/or excessive processing power of the computing resources.

Similarly, inserting or deleting nodes in a hierarchical data structurecan also result in lengthy delays and/or excessive increases inprocessing power of the computer resources. In particular, updatingnodes that depend on the inserted or deleted nodes may requiretraversing through all the nodes having a relationship with the insertedor deleted node and updating each of those nodes. For example,scheduling software might be used to manage project deadlines. When asingle job or operation within the hierarchy is modified, delayed, orcanceled, the estimated start and completion dates of all subsequentoperations might need to be re-computed serially before the finalcompletion date of the project can be made available. Since hierarchicaldata structures may include thousands of nodes, this approach can beboth time-consuming and a less-than-optimal use of computing resources.

What is needed is a system and method that provides a flexible way toupdate a hierarchical data structure based on the number of nodes in thehierarchical structure that need updating.

BRIEF DESCRIPTION OF THE DRAWINGS

In the following drawings like reference numbers are used to refer tolike elements. Although the following figures depict various examples,the one or more implementations are not limited to the examples depictedin the figures. Further, features illustrated in multiple figures arereferenced by the same reference numerals.

FIG. 1 illustrates a hierarchical tree structure, in accordance withsome embodiments.

FIG. 2 illustrates a hierarchical tree structure with the height, widthand levels of the tree displayed, in accordance with some embodiments.

FIG. 3 illustrates a flow chart of the process for generating ahierarchical tree representation based on defined node limits.

FIG. 4 illustrates a simple method of determining the number of nodesassociated with a set of hierarchical data in a relational databasetable.

FIG. 5 shows another method of implementing hierarchical data in arelational database table.

FIG. 6 shows another method of implementing hierarchical data in arelational database table.

FIG. 7 illustrates a flow chart of the process for updating ahierarchical tree representation based on defined node limits.

FIG. 8A shows a system diagram illustrating architectural components ofan applicable environment, in accordance with some embodiments;

FIG. 8B shows a system diagram further illustrating architecturalcomponents of an applicable environment, in accordance with someembodiments;

FIG. 9 shows a system diagram illustrating the architecture of amulti-tenant database environment, in accordance with some embodiments;and

FIG. 10 shows a system diagram further illustrating the architecture ofa multi-tenant database environment, in accordance with someembodiments.

DETAILED DESCRIPTION

Systems and method are provided for creating and managing hierarchicaldata structures based on structural limits. The structural limits maydictate the maximum number of nodes in the hierarchical data structureand/or dictate in what manner the hierarchical data structure isupdated.

Applications of the systems and methods according to one or moreembodiments are described in this section. These examples are beingprovided solely to add context and aid in the understanding of thepresent disclosure. It will thus be apparent to one skilled in the artthat the techniques described herein may be practiced without some orall of these specific details. In other instances, well known processsteps have not been described in detail in order to avoid unnecessarilyobscuring the present disclosure. Other applications are possible, suchthat the following examples should not be taken as definitive orlimiting either in scope or setting.

In the following detailed description, references are made to theaccompanying drawings, which form a part of the description and in whichare shown, by way of illustration, specific embodiments. Although theseembodiments are described in sufficient detail to enable one skilled inthe art to practice the disclosure, it is understood that these examplesare not limiting, such that other embodiments may be used and changesmay be made without departing from the spirit and scope of thedisclosure.

As used herein, the term “multi-tenant database system” refers to thosesystems in which various elements of hardware and software of thedatabase system may be shared by one or more customers. For example, agiven application server may simultaneously process requests for a greatnumber of customers, and a given database table may store rows for apotentially much greater number of customers.

The described subject matter may be implemented in the context of anycomputer-implemented system, such as a software-based system, a databasesystem, a multi-tenant environment, or the like. Moreover, the describedsubject matter may be implemented in connection with two or moreseparate and distinct computer-implemented systems that cooperate andcommunicate with one another. One or more embodiments may be implementedin numerous ways, including as a process, an apparatus, a system, adevice, a method, a computer readable medium such as a computer readablestorage medium containing computer readable instructions or computerprogram code, or as a computer program product comprising a computerusable medium having a computer readable program code embodied therein.

In general, a multi-tenant database environment may include multipledatabases configured to store data associated with organizations orcustomers. The data for the organization or the customer may beorganized in a hierarchical fashion. By organizing data in ahierarchical fashion, analysis and/or operations can be performedefficiently. Although multi-tenant database environment is discussed,the system and method discussed can be implemented in a single tenantdatabase environment.

Within the database, the data may be stored as nodes that are organizedrepresented as nodes in a hierarchical data structure. In oneembodiment, the hierarchical data structure may be a tree likestructure. The nodes are connected to one another through links thatrepresent the relationship between the nodes. The relationship betweenthe nodes is a parent-child relationship.

FIG. 1 illustrates an example of a hierarchical tree structure.

A hierarchical tree structures provides a way of organizing data withina database. The data is stored as records and each record is representedas a node in the tree structure. For example, each node A-S in FIG. 1represents a record in a database. In some instances, each noderepresents client data. In one embodiment, the hierarchical treestructure is of a file system wherein each node A-S represents a file,directory, or object, such as a document.

In a hierarchical tree representation, the root node is the very firstor parent node. A root node is just like any node, in that it is part ofa data structure, and represents a record which consists of one or morefields with links to other records and contains a data field; it simplyhappens to be the first node representing the first record. In FIG. 1,Node A is the root node for the hierarchical tree structure.

Besides the root node, each node within the tree has exactly one parentnode or predecessor node. Additionally, each node, including the rootnode, may have multiple child nodes or successor nodes. An edge is alink from a parent node to a child node. For Example, Node B in FIG. 3is the parent of Node E, Node F, and Node G; Node C is the parent ofNode H and Node I; and Node D is the parent of Node J and Node K. Leafnodes have no children. For example, Node N, Node P, Node Q and Node Rdoes are leaf nodes because these nodes have no children.

The hierarchical tree structure depicted in FIG. 1 allows anorganization or customer to traverse through the nodes in an organizedand efficient manner using various operations and/or algorithms forquerying data, mining data and the like. Properties of the hierarchicaltree structure are often used to define the structure and define theoperations/algorithms used on the hierarchical tree structure. Forexample, when generating a tree, the size of the tree may be limitedbased on properties (height of a tree or width of a tree) defined by anadministrator. In another example, properties of a tree may dictatewhich query algorithm is used.

FIG. 2 illustrates the properties of the hierarchical tree structuredepicted in FIG. 3.

Properties of a hierarchical tree structure may be represented by thenumber of levels in a tree, the height of a tree and width of a tree.

The number of levels within a tree is determined by determining thelevel of each node and identifying the node with the highest definedlevel. The level of a node may be defined by 1+ the number ofconnections between the node and the root. For example, the level ofRoot Node A is 1 (1+0 connections between the node and the root. Thelevel of Nodes B, C, and D is 2 (1+1 connection between the nodes andthe root). The level of Nodes E, F, G, H, I, J, and K is 3 (1+2connections between the nodes and the root). And, the level of Nodes N,O, P, Q, and R is 4 (1+3 connections between the nodes and the root).Nodes N, O, P, Q and R have the highest defined level (level 4).Therefore, the number of levels within the tree is 4.

The height of a hierarchical tree structure is determined by determiningthe height of the root node of the tree. The height of the root node isthe number of links (also referred to as relationships or edges) on thelongest downward path between a node and a leaf node. In FIG. 2, thenumber of links on the longest path downwards between root Node A andany of the leaf Nodes N, O, P, Q, and R is 3 links. The arrows in FIG. 2indicate the links for path 1 A-B-E-N which is one of the five pathsfrom root Node A to leaf Node N. The other four paths include: path 2A-B-E-O; path 3 A-B-G-P; path 4 A-D-K-Q; and path 5 A-D-K-R. All fivepaths have the same number of links, 3 links. Therefore, the height ofthe tree is 3.

The width of a hierarchical tree representation is the number of nodeson the longest path between two leaves in the tree. The number of nodeson the longest path in tree structure in FIG. 2 is 7. In one example,Nodes P, G, B, A, D, K, and R (highlighted in FIG. 2) represent one ofthe five longest paths between two leaf nodes within the tree. Thenumber of nodes on each of the other four paths is also 7 nodes.

FIG. 3 illustrates a hierarchical table representation of thehierarchical tree structure depicted in FIG. 1.

The table may consist of at least three columns, a column that stores aNode ID, a column that stores the Root Node ID and a column stores theParent Node ID. The Node ID stores the name or identification of each ofthe nodes depicted in the tree structure in FIG. 1. For each of thenodes the Root Node ID and Parent Node ID is identified and listed inthe respective columns. The table may comprise other columns notdepicted in FIG. 3. For example, the table may include a column forchildren Node ID, level ID and the like.

In one embodiment, the table may be a relational table wherein each rowrepresents a record that is represented as a node in the hierarchicaltree. The client data associated with the record may be stored withinthe table. Links from one of the record to another record may beincluded in the table.

The first row of the table represents Root Node A. Since Node A is aroot node, the Root Node ID would be the same as the Node ID.Additionally, since a root node does not have any parents, the ParentNode ID would be null. The parent Node ID will always be the same as theRoot Node ID for the highest hierarchical data element, the root node.

The second row, third row, and fourth row of the table depicts Nodes B,C and D having the same parent, Node A. In other words, the tabledisplays that Node A has 3 children, namely, Node B, Node C and Node D.Thus, the Root Node ID for each of Node B, Node C and Node D equals A(representing Node A).

Node E, Node F and Node G are children of parent Node B. Node B is thechild of parent Node A. In other words, Node A is a grand-parent ofNodes E, F and G. Therefore, in rows five, six and seven for respectiveNode E, Node F and Node G, the table lists Node B (the parent node) asthe Parent Node ID. In some embodiments, the Parent Node ID column willonly include the direct parent of the node. For example, the Parent NodeID for Node E would only include Node B as Node B is the direct parent.In some embodiments, the Parent Node ID column will include a lineage ofparents, such as a grand-parent Node or a great-grand-parent Node. Forexample, for Node E, Node B is the parent and Node A is the grand-parentnode and both Node B and Node A may be listed in the Parent Node IDcolumn. Node E, Node F and Node G all have the same root node, Node A.Therefore, the Root Node ID for Node E, Node F and Node G is the RootNode ID for Node A.

Rows eight to nineteen are similarly represent Nodes H-S represented inFIG. 1.

The hierarchical table shown in FIG. 3 provides enough information toretrieve all possible hierarchical relationships among the nodes andidentify the number of nodes within the hierarchical data structure. Thehierarchal table may be used to determine the relationships between thenodes. For example, the table can be queried, searched or traversed todetermine which nodes depend from Node G of FIG. 2.

Hierarchical data structures such as those depicted in FIGS. 1-3 havebeen a common data storage choice for different entities such ascorporations, enterprises, business and the like. Using the hierarchicaldata structures, entities are able to organize and manage large amountsof data efficiently. For example, entities are able to quickly siftthrough volumes of data, perform complex queries, and mine data moreaccurately. However, as the complexity of the relationships between thedata and the amount of data increases, the stress on computer resourcesperforming the sifting, querying and mining operations increases. If thestress on computer resources becomes too great, the computer resourcesmay crash or the operations may time out because the operation is takingtoo long to complete. In other words, if the volume, velocity andvariety of records represented as nodes in the hierarchical datastructure is too great, the hierarchical data structure often cannotdeliver the performance and latency required to handle large, complexoperations.

To prevent such catastrophes, entities may limit the number of nodes inthe hierarchical data structures. Hierarchical data structures, such astrees, may have limits on the height and the width of the tree. Asdiscussed above the height of a tree may be the number of links in thelongest downward path from a root node and the width of the tree may bethe number of nodes in the longest path from any two leaf nodes. Forexample, an administrator may restrict hierarchical tree structure to aheight of 20 links and width of 20 nodes. However, such rigidness inheight and width limits is undesirable. For example, a client may notneed a tree to have a height of 20 links but may need the tree to have awidth greater than 20 nodes. A more flexible and desirable alternativeis to have limits on the number of nodes that may be incorporated in ahierarchical tree, not a limit on the height and width of the tree.

To determine an optimal limit number of nodes that may be incorporatedinto a hierarchical data structure, a series of performance tests areperformed on the hierarchical data structure. Based on the results ofthe performance tests, a determination can be made as to the optimalnumber of nodes a hierarchical data structure may include so thatperformance and latency expectations met.

Simulation studies on real-time database systems that store data in ahierarchical data structure are performed to determine certainperformance metrics. The simulation studies use a variety of differentalgorithms for traversing through the hierarchical data structure. Forexample, different query designs may be used to test the hierarchicaldata structure. Performance metrics such as an average response time andthroughput, fault tolerance, scalability, mean-time to failure, meantime to repair, and the like are recorded. Based on the performancemetrics, an optimal number of nodes may be determined. For example,calculations may determine the number of nodes that can be accessedwithin a certain amount of time based on the average response timeperformance metric.

In another embodiment, a series of tests may be performed onhierarchical structures having different number of nodes. Based on theperformance test result, the hierarchical structure having the bestperformance test metrics will be selected as being optimal number ofnodes for the hierarchical data structure. The optimal number of nodesor the node limit can then be used to limit the size of a hierarchicaldata structure that is being generated.

FIG. 4 illustrates a flow chart for generating a hierarchical datastructure based on a node limit.

In step 401, an optimal number of nodes, or an optimal node limit, for ahierarchical data structure is determined. As described above, theoptimal number of nodes for a hierarchical data structure is based onperformance tests. In one embodiment, the optimal number of nodes is alimit that is set by an administrator and is not based on theperformance test.

In step 402, a plurality of records are received from a client device.The records may include at least one attribute that defining arelationship with the other records. For example, a client may provide alist of employees for a company. The list of employees may includeemployees Jack, Jill and Fred. For each employee, the client may specifytheir role within company which defines the relations between otheremployees on the list. For instance, the client may include in the listthat Jack is the CEO of the company, Jill is the sales manager of thecompany, and Fred is salesman.

Each record received by the client represents a node in the hierarchicaldata structure to be generated

In step 403, a hierarchical data structure comprising a plurality ofnodes is generated. Each of the nodes represents a record received fromthe client device.

In step 404, a determination is made as to whether the number of nodesin the hierarchical data structure exceeds the optimal node limit.

In one embodiment, after a client enters a first record, a hierarchicaldata structure is generated. The first record is represented in thehierarchical data structure as a first node. A running count of thenumber of nodes within the hierarchical data structure is maintained asmore records are received by the client. For example, once a secondrecord is received from the client, hierarchical data structure isupdated to include a second node. A running count of the number of nodeswithin the hierarchical data structure increase to 2 nodes after thehierarchical data structure was updated. Each time the hierarchical datastructure is updated with a new node, a determination may be made as towhether the number of nodes in the hierarchical data structure exceedsthe optimal record limit each time a data entry is received by a client.

In another embodiment, the number of nodes added to the hierarchicaldata structure is determined when all the records are received from theclient. For example, once the client has completed entering in all therecords, the client may select an option to generate or save the recordsin the hierarchical data structure. At that time, the number of nodesthat will represent each of the records is calculated and adetermination is made as to whether the calculated number nodes exceedthe optimal node limit.

In step 405, a notification is generated when the number of nodes in thehierarchical data structure exceeds the optimal node limit. In oneembodiment, the notification is an error message. The message may be ane-mail, text message, SMS message, a pop-up notification, and the like.

In another embodiment, the notification is a warning message sent to theclient and/or an administrator. For example, when the number of nodes inthe hierarchical data structure exceeds the selected optimal node limit,the client may be able to save the node within the hierarchical datastructure; however, operations, such as a query operation or a datamining operation, may be suspended until the hierarchical data structureis reformatted to conform with the optimal node limit. For example, aclient's request to query the hierarchical data structure may be denied.In such an instance, warning message may be sent to the client oradministrator indicating that operations may not be performed on thehierarchical data structure until the hierarchical data structure isreformatted.

If the client or administrator receives the notification, the client oradministrator may increase the optimal node limit. In some instances,the client or administrator may have to authorize payment or providepayment for the increase.

For example, the notification may include a link that allows anadministrator or client to increase the optimal node limit. In someinstances, the link may be hyperlink to an account portal that allowsthe client or administrator to log-in to a database providers site andprovide authorization or payment for increasing the optimal node limit.In some instances, the notification may a selectable widget that wouldprovide automatic authorization to increase the optimal node limit.

In one embodiment, when records are received by a client, a hierarchicaldata structure may not immediately be generated. For example, based onthe number of records received by a client, a determination can be madeas to how many nodes will be included in the hierarchical data structurerepresenting the received records. Based on this determination, anotification will be generated denying the generation of thehierarchical data structure if the number of nodes that will be includedin the hierarchical data structure will exceed the optimal node limit.

Once the hierarchical data structure is generated, an administrator orclient may want to update the data represented within the structure.Updating the data within a hierarchical data structure can becomecumbersome based on the size and complexity of the hierarchical datastructure. As the number of nodes stored in the hierarchical datastructure increases, the complexity of the relationships between thenodes increases. As the complexity of the relationships between thenodes increases, the time to update the nodes within the hierarchicaldata structure and the utilization of computer resources used to updatethe hierarchical data structure increases.

For example, scheduling software might be used to manage projectdeadlines. When a single job or operation within the hierarchy ismodified, delayed, or canceled, the estimated start and completion datesof all subsequent operations might need to be re-computed seriallybefore the final completion date of the project can be made available.Similarly, should the cost of any individual sub-assembly of a largermanufactured item change, the cost of an entire item that includes thatsub-assembly might need to be re-calculated by traversing the entirehierarchical data structure and re-computing all costs in the structureto account for the changed cost of the sub-assembly. Since hierarchicaldata structures may include thousands of nodes, updating a tree can beboth time-consuming and a less-than-optimal use of computing resources.

A more efficient way of performing updates in the hierarchical datastructure is to perform the updates synchronously in some instances andperform updates asynchronously in other instances.

In one embodiment, the performance of synchronous updates orasynchronous updates may be based on the size of the hierarchical datastructure. If the number of nodes in the hierarchical data structure isless than or equal to a threshold value, then updates to thehierarchical data structure would be done synchronously. If the numberof nodes in the hierarchical data structure is greater than a thresholdvalue, then the updates to the hierarchical data structure would be doneasynchronously. The threshold value may be the optimal node value oranother value determined by an administrator.

For example, if a client wants to update records associated with thenodes in a hierarchical tree structure, the number of nodes within thehierarchical tree structure is determined. If the number of nodes withinthe hierarchical tree structure is less than the optimal node value,then the update is performed synchronously. If the number of nodeswithin the hierarchical tree structure is greater than or equal to theoptimal node value, then the update is performed asynchronously. In oneembodiment, a notification may be generated if the hierarchical treestructure is going to be updated asynchronously.

In another embodiment, updates may be performed synchronously on some ofthe nodes that need to be updated and asynchronously on other nodes thatneed to be updated. For example, a system may determine the number ofnodes that need updating. If the number of nodes to be updated is lessthan or equal to a threshold value, then nodes may be synchronouslyupdated. On the other hand, if the number of nodes is greater than athreshold value, then the nodes are updated asynchronous. Providingsynchronous update operations and asynchronous update operations allowsfor a more efficient update process.

FIG. 5 illustrates a flow chart of the process for updating ahierarchical data structure based on defined node limits.

At step 501, updates for a hierarchical data structure are received by aclient device, where each updates correspond to a node in thehierarchical data structure. The updates may be for a first set ofnodes, wherein a set of nodes is one node or more. Updates may include,adding a node, deleting a node, amending the data within a node,re-parenting of a node or changing relationships between the node andother nodes. In one embodiment, the client may submit the updates to thenodes by changing the records that represent the nodes in thehierarchical data structure.

At step 502, at least one other node related to the node to be updatedis identified. For example, once a client submits updates for Node A, asdepicted in FIG. 1, Node B is identified because Node B is related toNode A. Node B is a child of Node A and comprises data that would beaffected by the update to Node A.

In one embodiment, other nodes are identified merely by the relationshiplink between the node to be updated and the other nodes. Therelationship links may be determined from querying a table as depictedin FIG. 3 or traversing a hierarchical structure as depicted in FIG. 2.In another embodiment, once the other nodes are identified by therelationship link to the node to be updated, the data associated withthe other identified nodes is analyzed to determine if the data in theother identified nodes is dependent on data associated with node thatneeds to be updated. For example, once Node B is identified, the dataassociated with Node B is analyzed to see if the data is dependent onthe data associated with Node A.

At step 503, the number of nodes from the first set of nodes and thesecond set of nodes that require updating is determined. For example,Node A has one child node, Node B, and Node B that contains data that isdependent on the data in Node A. Therefore, the number of nodes to beupdated would be 2 nodes (Node A+Node B).

At step 504, a synchronous update of the hierarchical data structure isperformed when the number of nodes to be updated is less than or equalto a threshold value. Synchronous update of the hierarchical datastructure includes updating the hierarchical data structure inreal-time. For example, the nodes that need updating are updated beforeanother operation is performed on the hierarchical data structure.

For instance, the threshold value of 3 nodes may have been determinedbased on performance tests. Since the number of nodes to be updated is 2nodes (Node A+Node B) as determined in step 503, and 2 nodes is lessthan 3 nodes, the hierarchical data structure is synchronously updated.If too many nodes are indicated as needing updating, the stress oncomputer resources and the time it takes to process all the updates maybe too great. For example, processing 10,000 record updates in asynchronous fashion may cause the database storing the nodes to crash orthe operation may time out because completion time of the operation istoo long. By limiting the number of synchronous updates to a thresholdvalue, database crashes and time-out operations may be avoided.

In one embodiment, the threshold value is the nodes limit that specifiesthe optimal number of nodes of the hierarchical data structure, asdescribed above in FIG. 4. In another embodiment, the threshold value isa number of nodes that are predefined by the administrator. Theadministrator may assign a threshold value based on performance testsindicating an optimal number of nodes that can be synchronously updated.

For example, a threshold value for the number of nodes that may besynchronously updated is set at 3 nodes. The threshold value wasdetermined based on performance tests of the computer resources thatwould be performing the updates to the hierarchical data structure.Performance tests of the hierarchical structure may also be performed.For example, performance testing indicating the time it takes to updatethe hierarchical structure or the amount of processing power it takes toupdate the hierarchical structure may be the basis of determining thethreshold value as the number of nodes that are updated is directlyrelated to the update time and processing power. Processing power ofcomputer resources performing update operations may be determined bytesting synchronous updates of a various number of nodes to determine abalance of processing power and the number of nodes. Based on the numberof nodes that would be able to be processed synchronously with optimalprocessing power by the resources, an optimal number of nodes would bedetermined to be the threshold value for synchronously updating nodes inthe hierarchical structure.

At step 505, an asynchronous update of the hierarchical tree isperformed when the number of nodes to be updated is greater than thethreshold value. An asynchronous update may include assigning the updateoperation to a queue wherein the update operation will eventually beprocessed. The updates are then triggered by an internally scheduled jobwhich then actually updates the data in the database. In one embodiment,the asynchronous update occurs when the process is offline or when theserver storing hierarchical data structure is not so busy.

In one embodiment, if the number of nodes to be updated is greater thanthe threshold value, then updates for nodes up to threshold value may beprocessed. The remaining updates may be queued for an asynchronousupdate. For example, if a threshold value is determined to be 30 nodesand the number of nodes that need updating is 70 nodes, the first 30nodes would be updated synchronously and the remaining 40 nodes (70nodes needing updating—30 nodes being updated synchronously) would beupdated asynchronously.

Additionally, in some instances, the nodes that need updating may beprioritized or ordered. For example, an administrator may determine thatnodes that need updating are ordered based on their relational distancefrom the root node, where nodes that have the shortest relationaldistance to the root node are updated before nodes having a longerrelational distance from the root node. In another instance, theadministrator may specify that updates may of child nodes occur beforeupdates of parent nodes.

FIG. 6 illustrates a user interface that may be used to create ahierarchical data structure.

In one embodiment, to generate a hierarchical data structure, a clientmay enter relational data entries in a spreadsheet, such as in MicrosoftExcel. The client may indicate relationships between the data enteredwithin the spreadsheet. For example, each leaf record may be representedin a single row of a spreadsheet. For each row may include a completetraversal from the leaf record to the root record. In another example,each record within the spreadsheet may include a relational link toanother record in the spreadsheet.

Once the client has generated the spreadsheet, the spreadsheet can beuploaded by selecting button 602 on the graphical user interface. Oncethe spreadsheet has been uploaded, the data entries may be extracted andtransformed into the hierarchical data structure. A preview of thehierarchical data structure may be generated automatically. In anotherembodiment, the client may select the preview button 610 to generate thepreview.

In another embodiment, to generate a hierarchical data structure, aclient may indicate where to find data and the data may be automaticallyretrieved and organized in a table or a tree format. If a client selectsthe retrieve data button 603, the client may be requested to enter in alink, website, directory or the like where the data is stored. Forexample, contact data for contacts on in a contact list may beretrieved. The contact data may be automatically organized in arelational table so that relationships between the contacts areindicated in the table. In one instance, the contact list may be acorporate employee list that includes the department each employee workfor and the role of the employee within the department. A client mayenter a link to where the contact list is stored. The contact list maythen be retrieved. A preview of the hierarchical data structure of thecontact list may be generated. To generate the hierarchical datastructure, the employees may be entered into a table, wherein eachemployee contains a relational link to at least one other employee. Thetable may be displayed to a client automatically or if the clientselects the preview button 610. The result is a hierarchicalrepresentation of the employees within the corporation. In anotherinstance, contacts from social media sites may be collected, mined orretrieved. Based on the data of the contacts on the social media sight,a hierarchical representation of the contacts may be generated in atable or spreadsheet, wherein the each record for each contact includesrelational links to at least one other record.

In yet another embodiment, to generate a hierarchical data structure,may enter data directly in the user interface. The client may select theadd record button 605. Once the client selects the add record button605, the client may enter data associated with the record in box 607. Insome instances, the client may define the relationship with at least oneother record in box 608. The client may then enter data for anotherrecord to be stored in the hierarchy data structure by selecting thenext record button 609. At any time while entering data for multiplerecords, the client may select the preview hierarchy button 610. In someinstances, a preview of the hierarchical data structure is automaticallydisplayed to the client in 612.

As the client enters data for each record, a counter is used to keeptrack of the number of records. If the number of records exceeds apredefined record limit, a notification is displayed to the client in613.

Once the data has been uploaded, entered or retrieved, the client mayselect the create hierarchy model. When the client selects the createhierarchy model, the data is permanently stored and the client mayperform operations, such as queries or mining, on the data.

FIG. 7 illustrates a user interface that may be used to update ahierarchical data structure.

A graphical user interface may depict the data that is organized intable or spreadsheet in a hierarchical tree representation 701 and/ormay also display a directory tree structure 702 representation of thedata. The directory tree structure 702 displays the hierarchy of thedata. For example, Record C has 2 children, Record D and E. Record B andRecord C have the same parent Record A. Although the graphical userinterface in FIG. 7 displays both the directory tree structure 702 andthe hierarchical tree structure 701, a client or administrator maychoose to display only one of the hierarchical tree structure 701 or thedirectory tree structure 702.

In one embodiment, the client may generate a hierarchical tree structureor a directory tree structure within the graphical user interfaceinstead of entering data into a table and then having a computerapplication convert the data entered in the table into a hierarchicaltree structure 701 or directory tree structure 702 that is displayed forthe client. For example, within the user interface, a client may chooseto create a hierarchy layout. The hierarchy layout may be a hierarchicaltree structure or a directory tree structure. A client may then enterdata for a root record in the hierarchy layout. Thereafter, the clientmay insert records into the hierarchy layout and provide links from theinserted records to other records within the hierarchy layout.Essentially, the client is generating the hierarchical tree structure ordirectory tree structure within the user interface.

Once the hierarchical tree structure 701 or the directory tree structure702 is generated and displayed to a client, the client may update thehierarchical tree structure 701 or the directory tree structure 702. Inone embodiment, the client may select a record that needs updating fromthe drop down box 704. In another embodiment, the client may select arecord that needs updating by selecting the record that needs updatingin the hierarchical tree structure 701 or the directory tree structure702. For example, a client may click on record A in the tree structure701 or record A in the directory tree structure, if the client wants toupdate record A.

When the record that needs updating is selected, data currently includedin the record may be displayed to the client in 705. Once the data isdisplayed, the client may be able to edit the data to reflect theupdating information. In one embodiment, the data currently included inthe selected record is not displayed to the client. However, the clientmay enter new data into box 705, wherein the entered data will replacethe data already stored in the selected record.

The client may also be able to add a new record or delete a record tothe existing. In one embodiment the client may select a button to add arecord or delete a record. A pop up box similar to box 708 may bedisplayed on the user interface in response to the add record box ordelete record box being selected.

If a record is being added, the pop up box may require the client toselect or input the records that will be related the new added record.For example, a client may want to add record F to the hierarchystructure. Once the client selects the Add record button, the client maybe prompted to enter a name for the record and enter data associatedwith the record. The use may also be prompted to provide the parentrecord that will be associated with record F and any children that willdepend on record F. In this example, the client may specify that RecordB will be the parent record of Record F and that record F does not haveany dependent child records.

If the client is deleting a record, the pop up box may include a warningof the other records within the tree or directory tree structure thatwill be affected by the deletion of the record. The client may also beprovided a warning to update any of the records that will be affected bythe deletion of the record.

In another embodiment, records may be added to the hierarchical treestructure and/or the directory tree structure by dragging and droppingrepresentations 712 of records into the hierarchical tree structureand/or the directory tree structure. Once a client adds the new recordrepresentation to into the hierarchical tree structure or directory treestructure, the client may be able to input data into box 705 that shouldbe associated with the newly added record.

In another embodiment, records may be deleted by dragging the recordfrom the tree structure or the directory tree structure and dropping therecord into the trash can 714. A message may be displayed to the clientso that the client may confirm the deletion of the record from the treestructure or directory tree structure.

Changes to the tree structure or the directory tree structure may not bereflected in the underlying data storage or database. In other words, aclient may make a plurality of changes to different records within thehierarchical structure rather than submitting one change at a time. Eachtime a client updates a record in the hierarchical structure, the clientmay select the next change button 711 if the client wants to make moreupdates to different records. Once the client has completed entering inall updates to the hierarchy structure, the client may preview thechanges by selecting the preview change button 707. An updated treestructure or directory tree structure will be displayed to the client.

To make the updates permanent and to have the changes reflected in thedatabase storing the hierarchical data, the client will select thesubmit changes button 707. Based on the number of records that wereupdated by the client and the number of records that need dependentupdates based on the records that were updated, the updates may beprocessed by the database synchronously or asynchronously. As describedin greater detail above, if the total number of records that need to beupdated is less than or equal to a predefined threshold value, then theupdate of records is performed synchronously. If the total number ofrecords that need to be updated is more than the predefined thresholdvalue, the records up to the predefined threshold value are updatedsynchronously and the remaining records are update asynchronously.

As shown in FIGS. 8A and 8B, accessing an on-demand service environmentmay involve communications transmitted among a variety of differenthardware and/or software components. Further, the on-demand serviceenvironment 800 is a simplified representation of an actual on-demandservice environment. For example, while only one or two devices of eachtype are shown in FIGS. 8A and 8B, some embodiments of an on-demandservice environment may include anywhere from one to many devices ofeach type. Also, the on-demand service environment need not include eachdevice shown in FIGS. 8A and 8B, or may include additional devices notshown in FIGS. 8A and 8B.

Moreover, one or more of the devices in the on-demand serviceenvironment 800 may be implemented on the same physical device or ondifferent hardware. Some devices may be implemented using hardware or acombination of hardware and software. Thus, terms such as “dataprocessing apparatus,” “machine,” “server” and “device” as used hereinare not limited to a single hardware device, but rather include anyhardware and software configured to provide the described functionality.

The cloud 804 is intended to refer to a data network or plurality ofdata networks, often including the Internet. Client machines located inthe cloud 804 may communicate with the on-demand service environment toaccess services provided by the on-demand service environment. Forexample, client machines may access the on-demand service environment toretrieve, store, edit, and/or process information.

In some embodiments, the edge routers 808 and 812 route packets betweenthe cloud 804 and other components of the on-demand service environment800. The edge routers 808 and 812 may employ the Border Gateway Protocol(BGP). The BGP is the core routing protocol of the Internet. The edgerouters 808 and 812 may maintain a table of IP networks or ‘prefixes’which designate network reachability among autonomous systems on theInternet.

In one or more embodiments, the firewall 816 may protect the innercomponents of the on-demand service environment 800 from Internettraffic. The firewall 816 may block, permit, or deny access to the innercomponents of the on-demand service environment 800 based upon a set ofrules and other criteria. The firewall 816 may act as one or more of apacket filter, an application gateway, a stateful filter, a proxyserver, or any other type of firewall.

In some embodiments, the core switches 820 and 824 are high-capacityswitches that transfer packets within the on-demand service environment800. The core switches 820 and 824 may be configured as network bridgesthat quickly route data between different components within theon-demand service environment. In some embodiments, the use of two ormore core switches 820 and 824 may provide redundancy and/or reducedlatency.

In some embodiments, the pods 840 and 844 may perform the core dataprocessing and service functions provided by the on-demand serviceenvironment. Each pod may include various types of hardware and/orsoftware computing resources. An example of the pod architecture isdiscussed in greater detail with reference to FIG. 8B.

In some embodiments, communication between the pods 840 and 844 may beconducted via the pod switches 832 and 836. The pod switches 832 and 836may facilitate communication between the pods 840 and 844 and clientmachines located in the cloud 804, for example via core switches 820 and824. Also, the pod switches 832 and 836 may facilitate communicationbetween the pods 840 and 844 and the database storage 856.

In some embodiments, the load balancer 828 may distribute workloadbetween the pods 840 and 844. Balancing the on-demand service requestsbetween the pods may assist in improving the use of resources,increasing throughput, reducing response times, and/or reducingoverhead. The load balancer 828 may include multilayer switches toanalyze and forward traffic.

In some embodiments, access to the database storage 856 may be guardedby a database firewall 848. The database firewall 848 may act as acomputer application firewall operating at the database applicationlayer of a protocol stack. The database firewall 848 may protect thedatabase storage 856 from application attacks such as structure querylanguage (SQL) injection, database rootkits, and unauthorizedinformation disclosure.

In some embodiments, the database firewall 848 may include a host usingone or more forms of reverse proxy services to proxy traffic beforepassing it to a gateway router. The database firewall 848 may inspectthe contents of database traffic and block certain content or databaserequests. The database firewall 848 may work on the SQL applicationlevel atop the TCP/IP stack, managing applications' connection to thedatabase or SQL management interfaces as well as intercepting andenforcing packets traveling to or from a database network or applicationinterface.

In some embodiments, communication with the database storage system 856may be conducted via the database switch 852. The multi-tenant databasesystem 856 may include more than one hardware and/or software componentsfor handling database queries. Accordingly, the database switch 852 maydirect database queries transmitted by other components of the on-demandservice environment (e.g., the pods 840 and 844) to the correctcomponents within the database storage system 856. In some embodiments,the database storage system 856 is an on-demand database system sharedby many different organizations. The on-demand database system mayemploy a multi-tenant approach, a virtualized approach, or any othertype of database approach. An on-demand database system is discussed ingreater detail with reference to FIGS. 9 and 10.

FIG. 8B shows a system diagram illustrating the architecture of the pod844, in accordance with one embodiment. The pod 844 may be used torender services to a user of the on-demand service environment 800. Insome embodiments, each pod may include a variety of servers and/or othersystems. The pod 844 includes one or more content batch servers 864,content search servers 868, query servers 872, file force servers 876,access control system (ACS) servers 880, batch servers 884, and appservers 888. Also, the pod 844 includes database instances 890, quickfile systems (QFS) 892, and indexers 894. In one or more embodiments,some or all communication between the servers in the pod 844 may betransmitted via the switch 836.

In some embodiments, the application servers 888 may include a hardwareand/or software framework dedicated to the execution of procedures(e.g., programs, routines, scripts) for supporting the construction ofapplications provided by the on-demand service environment 800 via thepod 844. Some such procedures may include operations for providing theservices described herein. The content batch servers 864 may requestsinternal to the pod. These requests may be long-running and/or not tiedto a particular customer. For example, the content batch servers 864 mayhandle requests related to log mining, cleanup work, and maintenancetasks.

The content search servers 868 may provide query and indexer functions.For example, the functions provided by the content search servers 868may allow users to search through content stored in the on-demandservice environment. The Fileforce servers 876 may manage requestsinformation stored in the Fileforce storage 878. The Fileforce storage878 may store information such as documents, images, and basic largeobjects (BLOBs). By managing requests for information using theFileforce servers 876, the image footprint on the database may bereduced.

The query servers 872 may be used to retrieve information from one ormore file systems. For example, the query system 872 may receiverequests for information from the app servers 888 and then transmitinformation queries to the NFS 896 located outside the pod. The pod 844may share a database instance 890 configured as a multi-tenantenvironment in which different organizations share access to the samedatabase. Additionally, services rendered by the pod 844 may requirevarious hardware and/or software resources. In some embodiments, the ACSservers 880 may control access to data, hardware resources, or softwareresources.

In some embodiments, the batch servers 884 may process batch jobs, whichare used to run tasks at specified times. Thus, the batch servers 884may transmit instructions to other servers, such as the app servers 888,to trigger the batch jobs. For some embodiments, the QFS 892 may be anopen source file system available from Sun Microsystems® of Santa Clara,Calif. The QFS may serve as a rapid-access file system for storing andaccessing information available within the pod 844. The QFS 892 maysupport some volume management capabilities, allowing many disks to begrouped together into a file system. File system metadata can be kept ona separate set of disks, which may be useful for streaming applicationswhere long disk seeks cannot be tolerated. Thus, the QFS system maycommunicate with one or more content search servers 868 and/or indexers894 to identify, retrieve, move, and/or update data stored in thenetwork file systems 896 and/or other storage systems.

In some embodiments, one or more query servers 872 may communicate withthe NFS 896 to retrieve and/or update information stored outside of thepod 844. The NFS 896 may allow servers located in the pod 844 to accessinformation to access files over a network in a manner similar to howlocal storage is accessed. In some embodiments, queries from the queryservers 822 may be transmitted to the NFS 896 via the load balancer 820,which may distribute resource requests over various resources availablein the on-demand service environment. The NFS 896 may also communicatewith the QFS 892 to update the information stored on the NFS 896 and/orto provide information to the QFS 892 for use by servers located withinthe pod 844.

In some embodiments, the pod may include one or more database instances890. The database instance 890 may transmit information to the QFS 892.When information is transmitted to the QFS, it may be available for useby servers within the pod 844 without requiring an additional databasecall. In some embodiments, database information may be transmitted tothe indexer 894. Indexer 894 may provide an index of informationavailable in the database 890 and/or QFS 892. The index information maybe provided to file force servers 876 and/or the QFS 892.

FIG. 9 shows a block diagram of an environment 910 wherein an on-demanddatabase service might be used, in accordance with some embodiments.Environment 910 includes an on-demand database service 916. User system912 may be any machine or system that is used by a user to access adatabase user system. For example, any of user systems 912 can be ahandheld computing system, a mobile phone, a laptop computer, a workstation, and/or a network of computing systems. As illustrated in FIGS.9 and 10, user systems 912 might interact via a network 914 with theon-demand database service 916.

An on-demand database service, such as system 916, is a database systemthat is made available to outside users that do not need to necessarilybe concerned with building and/or maintaining the database system, butinstead may be available for their use when the users need the databasesystem (e.g., on the demand of the users). Some on-demand databaseservices may store information from one or more tenants stored intotables of a common database image to form a multi-tenant database system(MTS). Accordingly, “on-demand database service 916” and “system 916”will be used interchangeably herein. A database image may include one ormore database objects. A relational database management system (RDBMS)or the equivalent may execute storage and retrieval of informationagainst the database object(s). Application platform 918 may be aframework that allows the applications of system 916 to run, such as thehardware and/or software, e.g., the operating system. In animplementation, on-demand database service 916 may include anapplication platform 918 that enables creation, managing and executingone or more applications developed by the provider of the on-demanddatabase service, users accessing the on-demand database service viauser systems 912, or third party application developers accessing theon-demand database service via user systems 912.

One arrangement for elements of system 916 is shown in FIG. 9, includinga network interface 920, application platform 918, tenant data storage922 for tenant data 923, system data storage 924 for system data 925accessible to system 916 and possibly multiple tenants, program code 926for implementing various functions of system 916, and a process space928 for executing MTS system processes and tenant-specific processes,such as running applications as part of an application hosting service.Additional processes that may execute on system 916 include databaseindexing processes.

The users of user systems 912 may differ in their respective capacities,and the capacity of a particular user system 912 might be entirelydetermined by permissions (permission levels) for the current user. Forexample, where a call center agent is using a particular user system 912to interact with system 916, the user system 912 has the capacitiesallotted to that call center agent. However, while an administrator isusing that user system to interact with system 916, that user system hasthe capacities allotted to that administrator. In systems with ahierarchical role model, users at one permission level may have accessto applications, data, and database information accessible by a lowerpermission level user, but may not have access to certain applications,database information, and data accessible by a user at a higherpermission level. Thus, different users may have different capabilitieswith regard to accessing and modifying application and databaseinformation, depending on a user's security or permission level.

Network 914 is any network or combination of networks of devices thatcommunicate with one another. For example, network 914 can be any one orany combination of a LAN (local area network), WAN (wide area network),telephone network, wireless network, point-to-point network, starnetwork, token ring network, hub network, or other appropriateconfiguration. As the most common type of computer network in currentuse is a TCP/IP (Transfer Control Protocol and Internet Protocol)network (e.g., the Internet), that network will be used in many of theexamples herein. However, it should be understood that the networks usedin some embodiments are not so limited, although TCP/IP is a frequentlyimplemented protocol.

User systems 912 might communicate with system 916 using TCP/IP and, ata higher network level, use other common Internet protocols tocommunicate, such as HTTP, FTP, AFS, WAP, etc. In an example where HTTPis used, user system 912 might include an HTTP client commonly referredto as a “browser” for sending and receiving HTTP messages to and from anHTTP server at system 916. Such an HTTP server might be implemented asthe sole network interface between system 916 and network 914, but othertechniques might be used as well or instead. In some embodiments, theinterface between system 916 and network 914 includes load sharingfunctionality, such as round-robin HTTP request distributors to balanceloads and distribute incoming HTTP requests evenly over a plurality ofservers. At least as for the users that are accessing that server, eachof the plurality of servers has access to the MTS' data; however, otheralternative configurations may be used instead.

In some embodiments, system 916, shown in FIG. 9, implements a web-basedcustomer relationship management (CRM) system. For example, in someembodiments, system 916 includes application servers configured toimplement and execute CRM software applications as well as providerelated data, code, forms, web pages and other information to and fromuser systems 912 and to store to, and retrieve from, a database systemrelated data, objects, and Webpage content. With a multi-tenant system,data for multiple tenants may be stored in the same physical databaseobject, however, tenant data typically is arranged so that data of onetenant is kept logically separate from that of other tenants so that onetenant does not have access to another tenant's data, unless such datais expressly shared. In certain embodiments, system 916 implementsapplications other than, or in addition to, a CRM application. Forexample, system 916 may provide tenant access to multiple hosted(standard and custom) applications. User (or third party developer)applications, which may or may not include CRM, may be supported by theapplication platform 918, which manages creation, storage of theapplications into one or more database objects and executing of theapplications in a virtual machine in the process space of the system916.

Each user system 912 could include a desktop personal computer,workstation, laptop, PDA, cell phone, or any wireless access protocol(WAP) enabled device or any other computing system capable ofinterfacing directly or indirectly to the Internet or other networkconnection. User system 912 typically runs an HTTP client, e.g., abrowsing program, such as Microsoft's Internet Explorer® browser,Mozilla's Firefox® browser, Opera's browser, or a WAP-enabled browser inthe case of a cell phone, PDA or other wireless device, or the like,allowing a user (e.g., subscriber of the multi-tenant database system)of user system 912 to access, process and view information, pages andapplications available to it from system 916 over network 914.

Each user system 912 also typically includes one or more user interfacedevices, such as a keyboard, a mouse, trackball, touch pad, touchscreen, pen or the like, for interacting with a graphical user interface(GUI) provided by the browser on a display (e.g., a monitor screen, LCDdisplay, etc.) in conjunction with pages, forms, applications and otherinformation provided by system 916 or other systems or servers. Forexample, the user interface device can be used to access data andapplications hosted by system 916, and to perform searches on storeddata, and otherwise allow a user to interact with various GUI pages thatmay be presented to a user. As discussed above, embodiments are suitablefor use with the Internet, which refers to a specific globalinternetwork of networks. However, it should be understood that othernetworks can be used instead of the Internet, such as an intranet, anextranet, a virtual private network (VPN), a non-TCP/IP based network,any LAN or WAN or the like.

According to some embodiments, each user system 912 and all of itscomponents are operator configurable using applications, such as abrowser, including computer code run using a central processing unitsuch as an Intel Pentium® processor or the like. Similarly, system 916(and additional instances of an MTS, where more than one is present) andall of their components might be operator configurable usingapplication(s) including computer code to run using a central processingunit such as processor system 917, which may include an Intel Pentium®processor or the like, and/or multiple processor units.

A computer program product implementation includes a machine-readablestorage medium (media) having instructions stored thereon/in which canbe used to program a computer to perform any of the processes of theembodiments described herein. Computer code for operating andconfiguring system 916 to intercommunicate and to process web pages,applications and other data and media content as described herein arepreferably downloaded and stored on a hard disk, but the entire programcode, or portions thereof, may also be stored in any other volatile ornon-volatile memory medium or device, such as a ROM or RAM, or providedon any media capable of storing program code, such as any type ofrotating media including floppy disks, optical discs, digital versatiledisk (DVD), compact disk (CD), microdrive, and magneto-optical disks,and magnetic or optical cards, nanosystems (including molecular memoryICs), or any type of media or device suitable for storing instructionsand/or data. Additionally, the entire program code, or portions thereof,may be transmitted and downloaded from a software source over atransmission medium, e.g., over the Internet, or from another server, ortransmitted over any other conventional network connection (e.g.,extranet, VPN, LAN, etc.) using any communication medium and protocols(e.g., TCP/IP, HTTP, HTTPS, Ethernet, etc.). It will also be appreciatedthat computer code for implementing embodiments can be implemented inany programming language that can be executed on a client system and/orserver or server system such as, for example, C, C++, HTML, any othermarkup language, Java™, JavaScript®, ActiveX®, any other scriptinglanguage, such as VBScript, and many other programming languages as arewell known may be used. (Java™ is a trademark of Sun Microsystems®,Inc.).

According to some embodiments, each system 916 is configured to provideweb pages, forms, applications, data and media content to user (client)systems 912 to support the access by user systems 912 as tenants ofsystem 916. As such, system 916 provides security mechanisms to keepeach tenant's data separate unless the data is shared. If more than oneMTS is used, they may be located in close proximity to one another(e.g., in a server farm located in a single building or campus), or theymay be distributed at locations remote from one another (e.g., one ormore servers located in city A and one or more servers located in cityB). As used herein, each MTS could include logically and/or physicallyconnected servers distributed locally or across one or more geographiclocations. Additionally, the term “server” is meant to include acomputing system, including processing hardware and process space(s),and an associated storage system and database application (e.g., OODBMSor RDBMS) as is well known in the art.

It should also be understood that “server system” and “server” are oftenused interchangeably herein. Similarly, the database object describedherein can be implemented as single databases, a distributed database, acollection of distributed databases, a database with redundant online oroffline backups or other redundancies, etc., and might include adistributed database or storage network and associated processingintelligence.

FIG. 10 also shows a block diagram of environment 910 furtherillustrating system 916 and various interconnections, in accordance withsome embodiments. FIG. 10 shows that user system 912 may includeprocessor system 912A, memory system 912B, input system 912C, and outputsystem 912D. FIG. 10 shows network 914 and system 916. FIG. 10 alsoshows that system 916 may include tenant data storage 922, tenant data923, system data storage 924, system data 925, User Interface (UI) 1030,Application Program Interface (API) 1032, PL/SOQL 1034, save routines1036, application setup mechanism 1038, applications servers10001-1000N, system process space 1002, tenant process spaces 1004,tenant management process space 1010, tenant storage area 1012, userstorage 1014, and application metadata 1016. In other embodiments,environment 910 may not have the same elements as those listed aboveand/or may have other elements instead of, or in addition to, thoselisted above.

User system 912, network 914, system 916, tenant data storage 922, andsystem data storage 924 were discussed above in FIG. 9. Regarding usersystem 912, processor system 912A may be any combination of processors.Memory system 912B may be any combination of one or more memory devices,short term, and/or long term memory. Input system 912C may be anycombination of input devices, such as keyboards, mice, trackballs,scanners, cameras, and/or interfaces to networks. Output system 912D maybe any combination of output devices, such as monitors, printers, and/orinterfaces to networks. As shown by FIG. 10, system 916 may include anetwork interface 920 (of FIG. 9) implemented as a set of HTTPapplication servers 1000, an application platform 918, tenant datastorage 922, and system data storage 924. Also shown is system processspace 1002, including individual tenant process spaces 1004 and a tenantmanagement process space 1010. Each application server 1000 may beconfigured to tenant data storage 922 and the tenant data 923 therein,and system data storage 924 and the system data 925 therein to serverequests of user systems 912. The tenant data 923 might be divided intoindividual tenant storage areas 1012, which can be either a physicalarrangement and/or a logical arrangement of data. Within each tenantstorage area 1012, user storage 1014 and application metadata 1016 mightbe similarly allocated for each user. For example, a copy of a user'smost recently used (MRU) items might be stored to user storage 1014.Similarly, a copy of MRU items for an entire organization that is atenant might be stored to tenant storage area 1012. A UI 1030 provides auser interface and an API 1032 provides an application programmerinterface to system 916 resident processes to users and/or developers atuser systems 912. The tenant data and the system data may be stored invarious databases, such as Oracle™ databases.

Application platform 918 includes an application setup mechanism 1038that supports application developers' creation and management ofapplications, which may be saved as metadata into tenant data storage922 by save routines 1036 for execution by subscribers as tenant processspaces 1004 managed by tenant management process 1010 for example.Invocations to such applications may be coded using PL/SOQL 34 thatprovides a programming language style interface extension to API 1032. Adetailed description of some PL/SOQL language embodiments is discussedin commonly assigned U.S. Pat. No. 7,730,478, titled METHOD AND SYSTEMFOR ALLOWING ACCESS TO DEVELOPED APPLICATIONS VIA A MULTI-TENANTON-DEMAND DATABASE SERVICE, by Craig Weissman, filed Sep. 21, 2007,which is hereby incorporated by reference in its entirety and for allpurposes. Invocations to applications may be detected by systemprocesses, which manage retrieving application metadata 1016 for thesubscriber making the invocation and executing the metadata as anapplication in a virtual machine.

Each application server 1000 may be communicably coupled to databasesystems, e.g., having access to system data 925 and tenant data 923, viaa different network connection. For example, one application server10001 might be coupled via the network 914 (e.g., the Internet), anotherapplication server 1000N−1 might be coupled via a direct network link,and another application server 1000N might be coupled by yet a differentnetwork connection. Transfer Control Protocol and Internet Protocol(TCP/IP) are typical protocols for communicating between applicationservers 1000 and the database system. However, other transport protocolsmay be used to optimize the system depending on the network interconnectused.

In certain embodiments, each application server 1000 is configured tohandle requests for any user associated with any organization that is atenant. Because it is desirable to be able to add and remove applicationservers from the server pool at any time for any reason, there ispreferably no server affinity for a user and/or organization to aspecific application server 1000. In some embodiments, therefore, aninterface system implementing a load balancing function (e.g., an F5Big-IP load balancer) is communicably coupled between the applicationservers 1000 and the user systems 912 to distribute requests to theapplication servers 1000. In some embodiments, the load balancer uses aleast connections algorithm to route user requests to the applicationservers 1000. Other examples of load balancing algorithms, such as roundrobin and observed response time, also can be used. For example, incertain embodiments, three consecutive requests from the same user couldhit three different application servers 1000, and three requests fromdifferent users could hit the same application server 1000. In thismanner, system 916 is multi-tenant, wherein system 916 handles storageof, and access to, different objects, data and applications acrossdisparate users and organizations.

As an example of storage, one tenant might be a company that employs asales force where each call center agent uses system 916 to manage theirsales process. Thus, a user might maintain contact data, leads data,customer follow-up data, performance data, goals and progress data,etc., all applicable to that user's personal sales process (e.g., intenant data storage 922). In an example of a MTS arrangement, since allof the data and the applications to access, view, modify, report,transmit, calculate, etc., can be maintained and accessed by a usersystem having nothing more than network access, the user can manage hisor her sales efforts and cycles from any of many different user systems.For example, if a call center agent is visiting a customer and thecustomer has Internet access in their lobby, the call center agent canobtain critical updates as to that customer while waiting for thecustomer to arrive in the lobby.

While each user's data might be separate from other users' dataregardless of the employers of each user, some data might beorganization-wide data shared or accessible by a plurality of users orall of the users for a given organization that is a tenant. Thus, theremight be some data structures managed by system 916 that are allocatedat the tenant level while other data structures might be managed at theuser level. Because an MTS might support multiple tenants includingpossible competitors, the MTS should have security protocols that keepdata, applications, and application use separate. Also, because manytenants may opt for access to an MTS rather than maintain their ownsystem, redundancy, up-time, and backup are additional functions thatmay be implemented in the MTS. In addition to user-specific data andtenant specific data, system 916 might also maintain system level datausable by multiple tenants or other data. Such system level data mightinclude industry reports, news, postings, and the like that are sharableamong tenants.

In certain embodiments, user systems 912 (which may be clientmachines/systems) communicate with application servers 1000 to requestand update system-level and tenant-level data from system 916 that mayrequire sending one or more queries to tenant data storage 922 and/orsystem data storage 924. System 916 (e.g., an application server 1000 insystem 916) automatically generates one or more SQL statements (e.g.,SQL queries) that are designed to access the desired information. Systemdata storage 924 may generate query plans to access the requested datafrom the database.

Each database can generally be viewed as a collection of objects, suchas a set of logical tables, containing data fitted into predefinedcategories. A “table” is one representation of a data object, and may beused herein to simplify the conceptual description of objects and customobjects according to some embodiments. It should be understood that“table” and “object” may be used interchangeably herein. Each tablegenerally contains one or more data categories logically arranged ascolumns or fields in a viewable schema. Each row or record of a tablecontains an instance of data for each category defined by the fields.For example, a CRM database may include a table that describes acustomer with fields for basic contact information such as name,address, phone number, fax number, etc. Another table might describe apurchase order, including fields for information such as customer,product, sale price, date, etc. In some multi-tenant database systems,standard entity tables might be provided for use by all tenants. For CRMdatabase applications, such standard entities might include tables foraccount, contact, lead, and opportunity data, each containingpre-defined fields. It should be understood that the word “entity” mayalso be used interchangeably herein with “object” and “table”.

In some multi-tenant database systems, tenants may be allowed to createand store custom objects, or they may be allowed to customize standardentities or objects, for example by creating custom fields for standardobjects, including custom index fields. U.S. Pat. No. 7,779,039, titledCUSTOM ENTITIES AND FIELDS IN A MULTI-TENANT DATABASE SYSTEM, byWeissman, et al., and which is hereby incorporated by reference in itsentirety and for all purposes, teaches systems and methods for creatingcustom objects as well as customizing standard objects in a multi-tenantdatabase system. In some embodiments, for example, all custom entitydata rows are stored in a single multi-tenant physical table, which maycontain multiple logical tables per organization. In some embodiments,multiple “tables” for a single customer may actually be stored in onelarge table and/or in the same table as the data of other customers.

These and other aspects of the disclosure may be implemented by varioustypes of hardware, software, firmware, etc. For example, some featuresof the disclosure may be implemented, at least in part, bymachine-program product that include program instructions, stateinformation, etc., for performing various operations described herein.Examples of program instructions include both machine code, such asproduced by a compiler, and files containing higher-level code that maybe executed by the computer using an interpreter. Examples ofmachine-program product include, but are not limited to, magnetic mediasuch as hard disks, floppy disks, and magnetic tape; optical media suchas CD-ROM disks; magneto-optical media; and hardware devices that arespecially configured to store and perform program instructions, such asread-only memory devices (“ROM”) and random access memory (“RAM”).

Any of the above embodiments may be used alone or together with oneanother in any combination. Although various embodiments may have beenmotivated by various deficiencies with the prior art, which may bediscussed or alluded to in one or more places in the specification, theembodiments do not necessarily address any of these deficiencies. Inother words, different embodiments may address different deficienciesthat may be discussed in the specification. Some embodiments may onlypartially address some deficiencies or just one deficiency that may bediscussed in the specification, and some embodiments may not address anyof these deficiencies.

While various embodiments have been described herein, it should beunderstood that they have been presented by way of example only, and notlimitation. Thus, the breadth and scope of the present applicationshould not be limited by any of the embodiments described herein, butshould be defined only in accordance with the following andlater-submitted claims and their equivalents.

1. A method comprising: receiving, by a database system, an update to afirst node of a plurality of nodes in a hierarchical data structure, thefirst node representing a record; identifying, by the database system,one or more other nodes of the plurality of nodes in the hierarchicaldata structure that needs to be updated based on the update to the firstnode; comparing, by the database system, the identified number of nodesto determine whether the identified number of nodes is one of less than,equal to and greater than a maximum number of nodes that can be updatedsynchronously; performing, by the database system, a synchronous updateof the first node and the identified nodes in response to adetermination that a number of nodes that need to be updated is lessthan or equal to the maximum number of nodes that can be updatedsynchronously, the number of nodes that need to be updated including thefirst node and the identified nodes; and performing, by the databasesystem, an asynchronous update of the first node and the identifiednodes in response to a determination that the number of nodes that needto be updated is greater than the maximum number of nodes that can beupdated synchronously, the number of nodes that need to be updatedincluding the first node and the identified nodes.
 2. The method ofclaim 1, wherein performing the synchronous and asynchronous update ofthe first node and the identified nodes includes updating recordsrepresented by the first node and the identified nodes in thehierarchical data structure.
 3. The method of claim 2, whereinperforming the asynchronous update includes storing the recordsrepresented by the first node and the identified nodes in thehierarchical data structure in a queue.
 4. The method of claim 3,further comprises: updating the records stored in the queue; andupdating the hierarchical data structure in response to updating therecords in the queue.
 5. The method of claim 1, further comprisinggenerating a notification when an asynchronous update is performed. 6.The method of claim 1, wherein the synchronous update is performed inreal time.
 7. The method of claim 1, further comprising identifying afirst set of the plurality of nodes to synchronously update and a secondset of the plurality of nodes to asynchronously update, when the numberof the first node and the identified nodes is greater than the maximumnumber of nodes.
 8. A system comprising: one or more processors; and anon-transitory computer readable medium storing a plurality ofinstructions, which when executed, causes the one or more processors to:receive an update to a first node of a plurality of nodes in ahierarchical data structure, the first node representing a record;identify one or more other nodes of the plurality of nodes in thehierarchical data structure that needs to be updated based on the updateto the first node; compare the identified number of nodes to determinewhether the identified number of nodes is one of less than, equal to andgreater than a maximum number of nodes that can be updatedsynchronously; perform a synchronous update of the first node and theidentified nodes in response to a determination that a number of nodesthat need to be updated is less than or equal to the maximum number ofnodes that can be updated synchronously, the number of nodes that needto be updated including the first node and the identified nodes; andperform an asynchronous update of the first node and the identifiednodes in response to a determination that the number of nodes that needto be updated is greater than the maximum number of nodes that can beupdated synchronously, the number of nodes that need to be updatedincluding the first node and the identified nodes.
 9. The system ofclaim 8, wherein performing the synchronous and asynchronous update ofthe first node and the identified nodes includes updating recordsrepresented by the first node and the identified nodes in thehierarchical data structure.
 10. The system of claim 9, whereinperforming the asynchronous update includes storing the recordsrepresented by the first node and the identified nodes in thehierarchical data structure in a queue.
 11. The system of claim 10,wherein the plurality of instructions, when executed, further cause theone or more processors to: update the records stored in the queue; andupdate the hierarchical data structure in response to updating therecords stored in the queue.
 12. The system of claim 8, wherein theplurality of instructions, when executed, further cause the one or moreprocessors to: generate a notification when the asynchronous update isperformed.
 13. The system of claim 8, wherein the synchronous update isperformed in real time.
 14. The system of claim 8, wherein the pluralityof instructions, when executed, further cause the one or more processorsto: identify a first set of the plurality of nodes to synchronouslyupdate and a second set of the plurality of nodes to asynchronouslyupdate, when the number of the first node and the identified nodes isgreater than the maximum number of nodes.
 15. A computer program productcomprising computer-readable program code to be executed by one or moreprocessors when retrieved from a non-transitory computer-readablemedium, the program code including instructions to: receive an update toa first node of a plurality of nodes in a hierarchical data structure,the first node representing a record; identify one or more other nodesof the plurality of nodes in the hierarchical data structure that needsto be updated based on the update to the first node; compare theidentified number of nodes to determine whether the identified number ofnodes is one of less than, equal to and greater than a maximum number ofnodes that can be updated synchronously; perform a synchronous update ofthe first node and the identified nodes in response to a determinationthat a number of nodes that need to be updated is less than or equal tothe maximum number of nodes that can be updated synchronously, thenumber of nodes that need to be updated including the first node and theidentified nodes; and perform an asynchronous update of the first nodeand the identified nodes in response to a determination that the numberof nodes that need to be updated is greater than the maximum number ofnodes that can be updated synchronously, the number of nodes that needto be updated including the first node and the identified nodes.
 16. Thecomputer program product of claim 15, wherein performing the synchronousand asynchronous update of the first node and the identified nodesincludes updating records represented by the first node and theidentified nodes in the hierarchical data structure.
 17. The computerprogram product of claim 16, wherein performing the asynchronous updateincludes storing the records represented by the first node and theidentified nodes in the hierarchical data structure in a queue.
 18. Thecomputer program product of claim 17, further comprising instructionsto: update the records stored in the queue; and update the hierarchicaldata structure in response to updating the records stored in the queue.19. The computer program product of claim 15, further comprisinginstructions to: generate a notification when the asynchronous update isperformed.
 20. The computer program product of claim 15, furthercomprising instructions to: identify a first set of the plurality ofnodes to synchronously update and a second set of the plurality of nodesto asynchronously update, when the number of the first node and theidentified nodes is greater than the maximum number of nodes.